package com.ts.api.http.receive.biz;


import com.gitee.apanlh.util.base.ChooseEq;
import com.gitee.apanlh.util.base.CollUtils;
import com.gitee.apanlh.util.base.MapUtils;
import com.gitee.apanlh.util.dataformat.JsonUtils;
import com.gitee.apanlh.util.reflection.CopyUtils;
import com.gitee.apanlh.util.valid.Assert;
import com.gitee.apanlh.util.valid.ValidParam;
import com.gitee.apanlh.web.model.vo.RequestVO;
import com.ts.api.common.constant.api.ApiEnum;
import com.ts.api.common.util.ApiDictUtils;
import com.ts.api.exp.ApiMsgException;
import com.ts.api.http.receive.entity.apply.req.ApiReceiveApplyMaskMaXiaoMi;
import com.ts.api.http.receive.entity.dataexchange.req.ApiReceiveDataExchangeMaskMaXiaoMi;
import com.ts.api.module.api.convert.receive.entity.ApiReceiveApply;
import com.ts.api.module.api.convert.receive.entity.ApiReceiveDecrypt;
import com.ts.api.module.api.convert.receive.entity.ApiReceiveNotice;
import com.ts.api.module.api.convert.receive.entity.ApiReceivePhoneMaskDataExchange;
import com.ts.api.module.api.convert.receive.handler.ApiReceivePhoneMaskConvertHandler;
import com.ts.api.module.api.entity.ApiUserRequest;
import com.ts.api.module.match.plan.internal.distribute.model.PlanDistributePhoneMaskField;

import java.util.List;
import java.util.Map;

/**
 * 码小米
 *
 * @ Author 江小游
 * @ Date 2025/6/12 09:42
 */
public abstract class ApiReceiveMaskMaXiaoMi implements ApiReceivePhoneMaskConvertHandler {
    @Override
    public Map<String, String> requireParam(RequestVO requestVO) throws Exception {
        //  获取请求体参数
        Map<String, Object> map = JsonUtils.toMap(requestVO.getBody());
        String channelCode = String.valueOf(map.get("channelCode"));
        String data = String.valueOf(map.get("data"));

        Assert.isNotEmptyThrows(channelCode, new ApiMsgException(ApiEnum.API_RECEIVE_BODY_MISS.format("method")));
        Assert.isNotEmptyThrows(data, new ApiMsgException(ApiEnum.API_RECEIVE_BODY_MISS.format("timestamp")));

        //  返回需要的数据Map
        return MapUtils.newHashMap(newMap -> {
            newMap.put("data", data);
            newMap.put("channelCode", channelCode);
        });
    }

    @Override
    public ApiUserRequest parseDataExchange(ApiReceiveDecrypt apiReceiveDecryptMessage) throws Exception {
        ApiReceiveDataExchangeMaskMaXiaoMi parse = apiReceiveDecryptMessage.parse(ApiReceiveDataExchangeMaskMaXiaoMi.class);
        ApiUserRequest apiUserRequest = CopyUtils.copy(parse, ApiUserRequest.class);
        fieldMapping(apiUserRequest);
        return apiUserRequest;
    }

    @Override
    public Map<String, Object> respDataExchange(ApiReceivePhoneMaskDataExchange dataExchangeMessage) throws Exception {
        List<PlanDistributePhoneMaskField> listPhoneMaskField = dataExchangeMessage.getListPhoneMaskField();

        return MapUtils.newLinkedHashMap(newMap -> {
            if (dataExchangeMessage.hasBizSuc()) {
                newMap.put("code", 0);
                newMap.put("msg", "撞库成功");
                newMap.put("data", CollUtils.newArrayList(newList -> {

                    for (PlanDistributePhoneMaskField planDistributePhoneMaskField: listPhoneMaskField) {
                        Map<String, Object> dataMap = MapUtils.newHashMap();
                        dataMap.put("applyId", planDistributePhoneMaskField.getApplyId());
                        dataMap.put("price", planDistributePhoneMaskField.getChannelSharePrice());
                        //  添加md5集合
                        dataMap.put("listPhoneMd5", planDistributePhoneMaskField.getListPhoneMd5());
                        newList.add(dataMap);
                    }
                }));
            } else {
                newMap.put("code", dataExchangeMessage.getBizCode());
                newMap.put("msg", dataExchangeMessage.getBizMsg());
            }
        });
    }

    @Override
    public ApiUserRequest parseApply(ApiReceiveDecrypt apiReceiveDecryptMessage) throws Exception {
        ApiReceiveApplyMaskMaXiaoMi parse = apiReceiveDecryptMessage.parse(ApiReceiveApplyMaskMaXiaoMi.class);
        ApiUserRequest apiUserRequest = CopyUtils.copy(parse, ApiUserRequest.class);
        fieldMapping(apiUserRequest);
        return apiUserRequest;
    }

    @Override
    public Map<String, Object> respApply(ApiReceiveApply applyMessage) throws Exception {
        Map<String, Object> resultMap = MapUtils.newLinkedHashMap();
        boolean suc = applyMessage.hasBizSuc();
        if (!suc) {
            resultMap.put("code", 500);
            resultMap.put("msg", applyMessage.getBizMsg());
            return resultMap;
        }

        resultMap.put("code", 0);
        resultMap.put("msg", "进件成功");
        return resultMap;
    }

    @Override
    public void fieldMapping(ApiUserRequest apiUserRequest) {
        //  年龄(21岁-55岁)
        String age = apiUserRequest.getAge();
        if (ValidParam.isNotEmpty(age)) {
            apiUserRequest.setAge(ApiDictUtils.convertAge(apiUserRequest.getAge()));
        }
        //  sex 性别：1-男、2-女
        //  sex 性别
        //  0 男
        //  1 女
        //  2 未知
        String sex = apiUserRequest.getSex();
        {
            String sexChoose = ChooseEq.create()
                    .when(sex, "1", "0")
                    .when(sex, "2", "1")
                    .end("2");
            apiUserRequest.setSex(sexChoose);
        }

        //  城市
        String city = apiUserRequest.getAreaCode();
        if (ValidParam.isNotEmpty(city)) {
            apiUserRequest.setCity(ApiDictUtils.getAreaNameByCode(city));
        }
        // 学历 1：本科以上 2：本科 3：大专 4：大专以下
        //  学历
        //   1.初中及以下
        //   2.中专
        //   3.高中
        //   4.大专
        //   5.本科
        //   6.研究生及以上
        String education = apiUserRequest.getEducationAttainment();
        if (ValidParam.isNotEmpty(education)) {
            String value = ChooseEq.create()
                    .when(education, "1", "6")
                    .when(education, "2", "5")
                    .when(education, "3", "4")
                    .when(education, "4", "3")
                    .end();
            apiUserRequest.setEducationAttainment(value);
        }
        // job 1：上班族， 2：企业主， 3：个体户， 4：事业单位/公务员， 5：自由职业
        // career
        //   1	上班族
        //   2	自由职业
        //   3	企业主（有营业执照）
        //   4	公务员或事业单位
        //   5	个体户
        String career = apiUserRequest.getCareer();
        if (ValidParam.isNotEmpty(career)) {
            String value = ChooseEq.create()
                    .when(career, "1", "1")
                    .when(career, "2", "3")
                    .when(career, "3", "5")
                    .when(career, "4", "4")
                    .when(career, "5", "2")
                    .end();
            apiUserRequest.setCareer(value);
        }
        // payoffForm  1-银行代发打卡、2-微信支付宝、3-现金
        // salaryPayMethod
        // 1 银行代发打卡
        // 2 现金收入
        // 3 个人转账
        String salaryPayMethod = apiUserRequest.getSalaryPayMethod();
        if (ValidParam.isNotEmpty(salaryPayMethod)) {
            String value = ChooseEq.create()
                    .when(salaryPayMethod, "1", "1")
                    .when(salaryPayMethod, "2", "3")
                    .when(salaryPayMethod, "3", "2")
                    .end();
            apiUserRequest.setSalaryPayMethod(value);
        }
        // 月薪 1：1万及以上， 2：5千-1万， 3：5千以内
        // 月收入
        // 1.1000-3000
        // 2.3000-8000
        // 3.8000~15000
        // 4.15000~30000
        // 5.30000以上
        String monthlySalary = apiUserRequest.getMonthlySalary();
        if (ValidParam.isNotEmpty(monthlySalary)) {
            String value = ChooseEq.create()
                    .when(monthlySalary, "1", "4")
                    .when(monthlySalary, "2", "2")
                    .when(monthlySalary, "3", "1")
                    .end();
            apiUserRequest.setMonthlySalary(value);
        }
        // 工作年限 1：12个月及以上， 2：6-12个月， 3：0-6个月
        //  单位工龄
        //   1.0-6个月
        //   2.6-12个月
        //   3.12个月以上
        String yearsService = apiUserRequest.getYearsService();
        if (ValidParam.isNotEmpty(yearsService)) {
            String value = ChooseEq.create()
                    .when(yearsService, "1", "3")
                    .when(yearsService, "2", "2")
                    .when(yearsService, "3", "1")
                    .end();
            apiUserRequest.setYearsService(value);
        }
        // 公司流水 1：10-50万， 2：50-100万， 3：100-300万， 4：300万及以上， 5：10万以内
        // 总经营流水
        // 1.10~50万元
        // 2.50~100万元
        // 3.100~500万元
        //
        //    private String bizBankDetails;
        String bizBankDetails = apiUserRequest.getBizBankDetails();
        if (ValidParam.isNotEmpty(bizBankDetails)) {
            String value = ChooseEq.create()
                    .when(bizBankDetails, "1", "1")
                    .when(bizBankDetails, "2", "2")
                    .when(bizBankDetails, "3", "3")
                    .when(bizBankDetails, "4", "3")
                    .when(bizBankDetails, "5", "1")
                    .end();
            apiUserRequest.setBizBankDetails(value);
        }
        // 公司营业执照注册年限 1：注册5年及以上， 2：注册1-5年， 3：注册1年以内
        // 营业执照注册年限
        // 1.未注册
        // 2.注册1年以下
        // 3.注册1~5年
        // 4.注册5年以上
        //    private String bizLicenseYear;
        String bizLicenseYear = apiUserRequest.getBizLicenseYear();
        if (ValidParam.isNotEmpty(bizLicenseYear)) {
            String value = ChooseEq.create()
                    .when(bizLicenseYear, "1", "4")
                    .when(bizLicenseYear, "2", "3")
                    .when(bizLicenseYear, "3", "2")
                    .end();
            apiUserRequest.setBizLicenseYear(value);
        }
        // socialSecurity 社保：1-六个月以上、2、六个月以下 3-无社保、
        // socialSecurity 社保缴纳
        // 1 无社保
        // 2 缴纳6个月以下
        // 3 缴纳6个月以上
        // 4 有社保
        String socialSecurity = apiUserRequest.getSocialSecurity();
        if (ValidParam.isNotEmpty(socialSecurity)) {
            String value = ChooseEq.create()
                    .when(socialSecurity, "1", "3")
                    .when(socialSecurity, "2", "2")
                    .when(socialSecurity, "3", "1")
                    .end();
            apiUserRequest.setSocialSecurity(value);
        }
        //  housingFund 公积金：1-六个月以上、2、六个月以下 3-无社保
        // providentFund 公积金
        // 1 无公积金
        // 2 缴纳6个月以下
        // 3 缴纳6个月以上
        // 4 有公积金
        String providentFund = apiUserRequest.getProvidentFund();
        if (ValidParam.isNotEmpty(providentFund)) {
            String value = ChooseEq.create()
                    .when(providentFund, "1", "3")
                    .when(providentFund, "2", "2")
                    .when(providentFund, "3", "1")
                    .end();
            apiUserRequest.setProvidentFund(value);
        }
        // houseProperty 房产：1：有全款房， 2：有按揭房， 3：无房产
        // realEstateInfo 房产情况
        // 1 无房产
        // 2 有房不抵押
        // 3 有房可抵押
        // 4 有房产
        // 5 有按揭房产
        // 6 有全款房产
        String realEstateInfo = apiUserRequest.getRealEstateInfo();
        if (ValidParam.isNotEmpty(realEstateInfo)) {
            String value = ChooseEq.create()
                    .when(realEstateInfo, "1", "6")
                    .when(realEstateInfo, "2", "5")
                    .when(realEstateInfo, "3", "1")
                    .end();
            apiUserRequest.setRealEstateInfo(value);
        }

        // carProperty 车产：1：有全款车， 2：有按揭车， 3：无车产
        // carInfo 车辆情况
        // 1 无车产
        // 2 有车不抵押
        // 3 有车可抵押
        // 4 有车产
        String carInfo = apiUserRequest.getCarInfo();
        if (ValidParam.isNotEmpty(carInfo)) {
            String value = ChooseEq.create()
                    .when(carInfo, "1", "4")
                    .when(carInfo, "2", "2")
                    .when(carInfo, "3", "1")
                    .end();
            apiUserRequest.setCarInfo(value);
        }
        //  insurance 保单：1：缴纳2年以上， 2：缴纳1年以上， 3：缴纳不足1年， 4：已缴清， 5：无保单
        // insurancePolicy 保险保单
        // 1 无保险保单
        // 2 缴纳未满1年
        // 3 缴纳1年以上
        // 4 有保险保单
        String insurancePolicy = apiUserRequest.getInsurancePolicy();
        if (ValidParam.isNotEmpty(insurancePolicy)) {
            String value = ChooseEq.create()
                    .when(insurancePolicy, "1", "3")
                    .when(insurancePolicy, "2", "3")
                    .when(insurancePolicy, "3", "2")
                    .when(insurancePolicy, "4", "4")
                    .when(insurancePolicy, "5", "1")
                    .end();
            apiUserRequest.setInsurancePolicy(value);
        }
        // 信用卡 1：有信用卡， 2：无信用卡
        //  信用卡额度
        //  1.无信用卡
        //  2.3千以下
        //  3.3千-1万
        //  4.1-3万
        //  5.3万以上
        //  6.有信用卡
        //    private String creditLimit;
        String creditLimit = apiUserRequest.getCreditLimit();
        if (ValidParam.isNotEmpty(creditLimit)) {
            String value = ChooseEq.create()
                    .when(creditLimit, "1", "6")
                    .when(creditLimit, "2", "1")
                    .end();
            apiUserRequest.setCreditLimit(value);
        }
        // sesameCredit  芝麻分：1：700分及以上， 2：650-700分， 3：600-650分， 4：600分以下， 5：无芝麻分
        // sesameCredit 芝麻分
        // 1 600分以下
        // 2 600~649分
        // 3 650~699分
        // 4 700分以上
        String sesameCredit = apiUserRequest.getSesameCredit();
        if (ValidParam.isNotEmpty(sesameCredit)) {
            String value = ChooseEq.create()
                    .when(sesameCredit, "1", "4")
                    .when(sesameCredit, "2", "3")
                    .when(sesameCredit, "3", "2")
                    .when(sesameCredit, "4", "1")
                    .end("1");
            apiUserRequest.setSesameCredit(value);
        }
        // creditInvestigation1：征信良好，
        //2：无人行征信，
        //3：有逾期，2年内60天以内的逾期，
        //4：有逾期，2年内60天以上的逾期，
        //5：有逾期，2年内90天以上的逾期
        // overdue 逾期
        // 1 无逾期
        // 2 当前有逾期
        // 3 一年以内无逾期
        String overdue = apiUserRequest.getOverdue();
        if (ValidParam.isNotEmpty(overdue)) {
            String value = ChooseEq.create()
                    .when(overdue, "1", "1")
                    .when(overdue, "3", "2")
                    .when(overdue, "4", "2")
                    .when(overdue, "5", "2")
                    .end();
            apiUserRequest.setOverdue(value);
        }
        // 借款金额 整数（单位：元）
        String loanAmount = apiUserRequest.getLoanAmount();
        if (ValidParam.isNotEmpty(loanAmount)) {
            String value = ApiDictUtils.convertLoanAmount(apiUserRequest.getLoanAmount(), false);
            apiUserRequest.setLoanAmount(value);
        }
        // 借款周期：3，6，9，12，24（单位：月）
        String loanTerm = apiUserRequest.getLoanTerm();
        if (ValidParam.isNotEmpty(loanTerm)) {
            String value = ChooseEq.create()
                    .when(loanTerm, "3", "1")
                    .when(loanTerm, "6", "2")
                    .when(loanTerm, "9", "2")
                    .when(loanTerm, "12", "3")
                    .when(loanTerm, "24", "4")
                    .end("1");
            apiUserRequest.setLoanTerm(value);
        }
    }

    @Override
    public Object reqPullApplyNotice(ApiReceiveNotice apiNoticeMessage) {
        return null;
    }

    @Override
    public boolean respPullApplyNotice(String responseBody) {
        return false;
    }

    @Override
    public Object reqPushApplyNotice(ApiReceiveNotice apiNoticeMessage) {
        return null;
    }

    @Override
    public boolean respPushApplyNotice(String responseBody) {
        return false;
    }
}
